#!/usr/bin/enr/python3
# -*- coding: utf-8 -*-
# -------------------------------
# @Author : hurong
# @File : day06运算符.py
# @Time : 2025/7/5 14:28
# -------------------------------
'''

##  Python语言中的运算符

Python 语言支持很多种运算符，下面的表格按照运算符的优先级从高到低，对 Python 中的运算符进行了罗列。有了变量和运算符，我们就可以构造各种各样的表达式来解决实际问题。在计算机科学中，**表达式是计算机程序中的句法实体，它由一个或多个常量、变量、函数和运算符组合而成，编程语言可以对其进行解释和计算以得到另一个值**。不理解这句话没有关系，但是一定要知道，不管使用什么样的编程语言，构造表达式都是非常重要的。

| 运算符                                                       | 描述                           |
| ------------------------------------------------------------ | ------------------------------ |
| `[]`、`[:]`                                                 | 索引、切片                  |
| `**`                                                         | 幂                             |
| `~`、`+`、`-`                                              | 按位取反、正号、负号         |
| `*`、`/`、`%`、`//`                                       | 乘、除、模、整除            |
| `+`、`-`                                                    | 加、减                        |
| `>>`、`<<`                                                  | 右移、左移                    |
| `&`                                                          | 按位与                         |
| `^`、`|`                                                   | 按位异或、按位或              |
| `<=`、`<`、`>`、`>=`                                      | 小于等于、小于、大于、大于等于 |
| `==`、`!=`                                                   | 等于、不等于                  |
| `is`、`is not`                                               | 身份运算符                     |
| `in`、`not in`                                                | 成员运算符                     |
| `not`、`or`、`and`                                             | 逻辑运算符                     |
| `=`、`+=`、`-=`、`*=`、`/=`、`%=`、`//=`、`**=`、`&=`、`\|=`、`^=`、`>>=`、`<<=` | 赋值运算符             |

>**说明**： 所谓优先级就是在一个运算的表达式中，如果出现了多个运算符，应该先执行什么再执行什么的顺序。编写代码的时候，如果搞不清楚一个表达式中运算符的优先级，可以使用圆括号（小括号）来确保运算的执行顺序。

'''

"""
算术运算符
"""
print(321 + 12)     # 加法运算，输出333
print(321 - 12)     # 减法运算，输出309
print(321 * 12)     # 乘法运算，输出3852
print(321 / 12)     # 除法运算，输出26.75
print(321 // 12)    # 整除运算，输出26
print(321 % 12)     # 求模运算，输出9
print(321 ** 12)    # 求幂运算，输出1196906950228928915420617322241

"""
算术运算的优先级：在括号中的会优先执行
"""
print(2 + 3 * 5)           # 17
print((2 + 3) * 5)         # 25
print((2 + 3) * 5 ** 2)    # 125
print(((2 + 3) * 5) ** 2)  # 625

"""
赋值运算符和复合赋值运算符

"""
a = 10
b = 3
a += b        # 相当于：a = a + b
a *= a + 2    # 相当于：a = a * (a + 2)
print(a)      # 大家算一下这里会输出什么195

"""
海象运算符：赋值运算构成的表达式本身不产生任何值，即，把一个赋值表达式放到print函数中试图输出表达式的值，将会产生语法错误。
为了解决这个问题，Python 3.8 中引入了一个新的赋值运算符:=，我们称之为海象运算符，
海象运算符也是将运算符右侧的值赋值给左边的变量，与赋值运算符不同的是，运算符右侧的值也是整个表达式的值

"""
# SyntaxError: invalid syntax
# print((a = 10))       # SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?
print((a == 10))    # == 为输出布尔值
# 海象运算符
print(f"输出海象赋值后，a的值：{(a := 10)}")  # 10
print(f"输出a的值：{a}")          # 10

"""
比较运算符和逻辑运算符的使用
比较运算符：==、!=、<、>、<=、>=
逻辑运算符：and、or、not
"""
flag0 = 1 == 1
flag1 = 3 > 2
flag2 = 2 < 1
flag3 = flag1 and flag2
flag4 = flag1 or flag2
flag5 = not flag0
print('flag0 =', flag0)     # flag0 = True
print('flag1 =', flag1)     # flag1 = True
print('flag2 =', flag2)     # flag2 = False
print('flag3 =', flag3)     # flag3 = False
print('flag4 =', flag4)     # flag4 = True
print('flag5 =', flag5)     # flag5 = False
print(flag1 and not flag2)  # True
print(1 > 2 or 2 == 3)      # False
# 比较运算符的优先级高于赋值运算符，所以上面的flag0 = 1 == 1先做1 == 1产生布尔值True，
# 再将这个值赋值给变量flag0。print函数可以输出多个值，多个值之间可以用,进行分隔，输出的内容默认以空格分开。
print( "*********************"+ '这是分割线' + "************************")

# 赋值运算符
def ass_info():
    
    # 赋值运算符 =
    # 1 = 2   # 运行报错：SyntaxError: cannot assign to literal here. Maybe you meant '==' instead of '='?
    # _1 = 2  # False,合法
    num = 2 + 3 * 5
    print(f"num的值：{num}")

    # 给多个变量赋值
    a, b, c = 1, 2, 4
    print(f"输出a,b,c的值为：{a, b, c}")

    # 复合赋值运算符
    num1 = 10
    num1 += 10  # num1 = num1 + 10
    print(f"num1的值：{num1}")

    num2 = 2
    num2 *= 3 + 4  #  乘法赋值，等于 2*（3+4）；3+4=7, 7*2=14  (算数优先级 ＞ 赋值运算符)
    print(f"num2的值为：{num2}")

ass_info()

print( "*********************"+ '这是分割线' + "************************")
print(f"总结：1. 简单的赋值运算符 =，等号右侧的可以是任意数据，将任意数据保存在等号左侧；2.等号左侧必须是个变量；"
      f"3.复合赋值运算符--赋值运算符和算数运算符的结合，注意：算数优先级高于赋值运算符，从右到左计算\n")

print( "*********************"+ '关系运算符' + "************************")
def rel_info():

    # 等于 ==
    print( 1 == 1)  # True
    print('abc' == "ABC") # False
    print(1 == '1') # False
    print('abc' == 'abc') # True

    print('*' * 10 + '这是分割线' + '*' * 10 )
    # 不等于 ！=
    print( 1 != 2)  # True
    print( 1 != '1')    # True
    print(  1 != '2')   # True
    print("ABC" != 'abc')   # True

    print('*' * 10 + '这是分割线' + '*' * 10)
    # 大于 >
    print(1 > 1)    # F
    print( 1 > 2)   # F
    print( 1 > 0)   # T
    print('a' > 'A')    # T
    print('abc' > 'ABC')    # T
    # print(1 > "a")      # 报错：TypeError: '>' not supported between instances of 'int' and 'str'

    print('*' * 10 + '这是分割线' + '*' * 10)
    # 大于等于 >=
    print( 1 >= 1) # T
    print( 1>= 2 )  # F

    print('*' * 10 + '这是分割线' + '*' * 10)
    # 小于等于 <=
    print(1 <= 1)  # T
    print(1 <= 2)  # T
    print('*'*10+f"关系比较运算符：= 、!=、>=、<=、>、<")

rel_info()

print( "*********************"+ '逻辑运算符' + "************************")
'''
1. 连接组合多个条件式；2.返回布尔值；3.短路特性：非短路操作，短路操作。
and:逻辑与，x and y,如果x为false,x and y返回False，否则它返回y的计算值。y可能是一个数值、可能是关系表达式、
也可能是另一个逻辑表达式；关键是看y是如何计算的。
or:逻辑或，x or y，如果x是非0，它返回x的计算值，否则它返回y的计算值。
not:逻辑非，not x ,如果x为True，返回False；如果x为False，它返回True
'''
def logi_info():

    # 逻辑与运算符（and）;逻辑与运算符来连接多个关系运算，当多个条件同时满足，结果为真True，否则False
    # 逻辑与 and
    print(1>0 and 2>0)  # 返回True,1>0为true，则返回2>0的结果，因为2>0为true，所以最终返回true
    print(1<0 and 2>0)
    print(1>0 and 2<0)
    print(1<2 and "H" + "W")    # HW
    print(True and 5)   # 5

    # 逻辑或运算符（or):
    print(1>0 or 2>1)  # True
    print(1 < 0 or 2 > 1)  # True
    print(1 > 0 or 2 < 1)  # True
    print(1 < 0 or 2 < 1)   # False
    print(4 or False)   # 4
    print(False or 'H') # H
    print(0 or 2+3) # 5

    # 逻辑非运算符（not)
    print(not True)     # False
    print(not False)    # True
    # 逻辑运算符，短路操作：在使用逻辑与运算符和逻辑或运算符时，自左向右计算结果可以确定整个表达式的结果时，后面的表达式条件不再计算。
    '''非短路操作'''
    result = True and print("python1") # 第一个操作为True，不能确定后面都为真，所以会继续执行print操作，print会打印出来；
    print(result)   # 输出None，print语句的返回值为None
    result1 = False or print('Hello, world!2') # 第一个操作为False，则继续执行，所以会继续执行print操作，输出print语句；
    print(result1)  # 输入None,print语句范围值为None

    '''短路操作'''
    rel = False and 1/0 # 逻辑与，第一个为假，后面就不用运算了。第一个操作为False，则后面的算式无需再操作；
    print(f"rel的值{rel}")    # 输出打印值False
    rel_1 = True or 1/0     # 逻辑或，一个为真，后面不用计算；
    print(f"rel_1的值{rel_1}")    # 输出打印值True
    '''当我们使用逻辑运算符，去关联组合多个关联关系或者表达式的时候，如果前面的表达式能判断当前整体的结果，后面就不用计算了，称之为短路特性。'''


# 调用函数运行
logi_info()

print( "*********************"+ '成员运算符' + "************************")
'''
in:如果再指定的序列中到值返回True，否则返回False；
not in:如果在指定的序列中没有找到值返回True，否则返回False。
'''

def member_info():
    # in
    print('o' in 'Hogwarts')    # True
    print("k" in 'Hogwarts')    # False
    print(3 in [1,2,3,4,5])     # True
    print(0 in [1,2,3,4,5])     # False
    print('python' in ('hello','world','python'))   # True
    print('abc' in ('hello','world','python'))  # False
    print('Tom' in {"name":"Tom","age":12})     # False
    print('name' in {"name":"Tome","age":123})  # True
    print('*' * 20)
#     not in  是一个完整的运算符
    print('o' not in 'Hogwarts')    # False
    print("k" not in 'Hogwarts')    # True
    print(3 not in [1,2,3,4,5])     # False
    print(0 not in [1,2,3,4,5])     # False
    print('python' not in ('hello','world','python'))   # False
    print('abc' not in ('hello','world','python'))  # True
    print('Tom' not in {"name":"Tom","age":12})     # True
    print('name' not in {"name":"Tome","age":123})  # False
member_info()


